﻿<h1>一些可能的内存泄漏场景</h1>

<p>
当使用一门支持自动垃圾回收的语言编程时，一般来说我们不需要关心内存泄露问题，因为程序的运行时会负责回收不再使用的内存。
但是，我们确实也需要知道一些特殊的可能会造成暂时性或永久性内存泄露的情形。
本文的余下部分将列出一些这样的情形。
</p>

<a class="anchor" id="substring"></a>
<h3>子字符串造成的暂时性内存泄露</h3>

<div>
<p>
Go白皮书并没有说明一个子字符串表达式的结果（子）字符串和基础字符串是否应该共享一个承载<a href="string.html">底层字节序列</a>的<a href="memory-block.html">内存块</a>。
但标准编译器确实让它们共享一个内存块，而且很多标准库包的函数原型设计也默认了这一点。
这是一个好的设计，它不仅节省内存，而且还减少了CPU消耗。
但是有时候它会造成暂时性的内存泄露。
</p>

比如，当下面这段代码中的<code>demo</code>函数被调用之后，将会造成大约1M字节的暂时性内存泄露，直到包级变量<code>s0</code>的值在其它某处被重新修改为止。

<pre class="line-numbers"><code class="language-go">var s0 string // 一个包级变量

// 一个演示目的函数。
func f(s1 string) {
	s0 = s1[:50]
	// 目前，s0和s1共享着承载它们的字节序列的同一个内存块。
	// 虽然s1到这里已经不再被使用了，但是s0仍然在使用中，
	// 所以它们共享的内存块将不会被回收。虽然此内存块中
	// 只有50字节被真正使用，而其它字节却无法再被使用。
}

func demo() {
	s := createStringWithLengthOnHeap(1 << 20) // 1M bytes
	f(s)
}
</code></pre>

<p>
</p>

为防止上面的<code>f</code>函数产生临时性内存泄露，我们可以将子字符串表达式的结果转换为一个字节切片，然后再转换回来。

<pre class="line-numbers"><code class="language-go">func f(s1 string) {
	s0 = string([]byte(s1[:50]))
}
</code></pre>

<p>
此种防止临时性内存泄露的方法不是很高效，因为在此过程中底层的字节序列被复制了两次，其中一次是不必要的。
</p>

我们可以利用<a href="string.html#conversion-optimizations">官方Go标准编译器对字符串衔接所做的优化</a>来防止一次不必要的复制，代价是有一个字节的浪费。

<pre class="line-numbers"><code class="language-go">func f(s1 string) {
	s0 = (" " + s1[:50])[1:]
}
</code></pre>

<p>
此第二种防止临时性内存泄露的方法有可能在将来会失效，并且它对于其它编译器来说很可能是无效的。
</p>

第三种防止临时性内存泄露的方法是使用在Go 1.10种引入的<code>strings.Builder</code>类型来防止一次不必要的复制。

<pre class="line-numbers"><code class="language-go">import "strings"

func f(s1 string) {
	var b strings.Builder
	b.Grow(50)
	b.WriteString(s1[:50])
	s0 = b.String()
}
</code></pre>

<p>
此第三种方法的缺点是它的实现有些啰嗦（和前两种方法相比）。
一个好消息是，从Go 1.12开始，我们可以调用<code>strings</code>标准库包中的<code>Repeat</code>函数来克隆一个字符串。
从Go 1.12开始，此函数将利用<code>strings.Builder</code>来防止一次不必要的复制。
</p>

<p>
从Go 1.17开始，<code>strings</code>标准库包中引入了一个<code>Clone</code>函数。
调用此函数为克隆一个字符串的最佳实现方式。
</p>

</div>

<a class="anchor" id="subslice"></a>
<h3>子切片造成的暂时性内存泄露</h3>

<div>
和子字符串情形类似，子切片也可能会造成暂时性的内存泄露。
在下面这段代码中，当函数<code>g</code>被调用之后，承载着切片<code>s1</code>的元素的内存块的开头大段内存将不再可用（假设没有其它值引用着此内存块）。
同时因为<code>s0</code>仍在引用着此内存块，所以此内存块得不到释放。

<pre class="line-numbers"><code class="language-go">var s0 []int

func g(s1 []int) {
	// 假设s1的长度远大于30。
	s0 = s1[len(s1)-30:]
}
</code></pre>

<p>
</p>

如果我们想防止这样的临时性内存泄露，我们必须在函数<code>g</code>中将30个元素均复制一份，使得切片<code>s0</code>和<code>s1</code>不共享承载底层元素的内存块。

<pre class="line-numbers"><code class="language-go">func g(s1 []int) {
	s0 = make([]int, 30)
	copy(s0, s1[len(s1)-30:])
	// 现在，如果再没有其它值引用着承载着s1元素的内存块，
	// 则此内存块可以被回收了。
}
</code></pre>

<p>
</p>

</div>

<a class="anchor" id="dead-slice-elements"></a>
<h3>因为未重置丢失的切片元素中的指针而造成的临时性内存泄露</h3>

<div>
在下面这段代码中，<code>h</code>函数调用之后，<code>s</code>的首尾两个元素将不再可用。

<pre class="line-numbers"><code class="language-go">func h() []*int {
	s := []*int{new(int), new(int), new(int), new(int)}
	// 使用此s切片 ...

	return s[1:3:3]
}
</code></pre>

<p>
只要<code>h</code>函数调用返回的切片仍在被使用中，它的各个元素就不会回收，包括首尾两个已经丢失的元素。
因此这两个已经丢失的元素引用着的两个<code>int</code>值也不会被回收，即使我们再也无法使用这两个<code>int</code>值。
</p>

为了防止这样的暂时性内存泄露，我们必须重置丢失的元素中的指针。

<pre class="line-numbers"><code class="language-go">func h() []*int {
	s := []*int{new(int), new(int), new(int), new(int)}
	// 使用此s切片 ...

	s[0], s[len(s)-1] = nil, nil // 重置首尾元素指针
	return s[1:3:3]
}
</code></pre>

<p>
</p>

<p>
我们经常需要在<a href="container.html#slice-manipulations">删除切片元素操作</a>中重置一些切片元素中的指针值。
</p>

</div>

<a class="anchor" id="hanging-goroutine"></a>
<h3>因为协程被永久阻塞而造成的永久性内存泄露</h3>

<div>
<p>
有时，一个程序中的某些协程会永久处于阻塞状态。
Go运行时并不会将处于永久阻塞状态的协程杀掉，因此永久处于阻塞状态的协程所占用的资源将永得不到释放。
</p>

<p>
Go运行时出于两个原因并不杀掉处于永久阻塞状态的协程。
一是有时候Go运行时很难分辨出一个处于阻塞状态的协程是永久阻塞还是暂时性阻塞；二是有时我们可能故意永久阻塞某些协程。
</p>

<p>
我们应该避免因为代码设计中的一些错误而导致一些协程处于永久阻塞状态。
</p>

</div>

<h3>因为没有停止不再使用的<code>time.Ticker</code>值而造成的永久性内存泄露</h3>

<p>
当一个<code>time.Timer</code>值不再被使用，一段时间后它将被自动垃圾回收掉。
但对于一个不再使用的<code>time.Ticker</code>值，我们必须调用它的<code>Stop</code>方法结束它，否则它将永远不会得到回收。
</p>

<h3>因为不正确地使用终结器（finalizer）而造成的永久性内存泄露</h3>

<div>
<p>
将一个终结器设置到一个循环引用值组中的一个值上可能导致<a href="https://golang.google.cn/pkg/runtime/#SetFinalizer">被此值组中的值所引用的内存块永远得不到回收</a>。
</p>

比如，当下面这个函数被调用后，承载着<code>x</code>和<code>y</code>的两个内存块将不保证会被逐渐回收。

<pre class="line-numbers"><code class="language-go">func memoryLeaking() {
	type T struct {
		v [1<<20]int
		t *T
	}

	var finalizer = func(t *T) {
		 fmt.Println("finalizer called")
	}

	var x, y T

	// 此SetFinalizer函数调用将使x逃逸到堆上。
	runtime.SetFinalizer(&x, finalizer)

	// 下面这行将形成一个包含x和y的循环引用值组。
	// 这有可能造成x和y不可回收。
	x.t, y.t = &y, &x // y也逃逸到了堆上。
}
</code></pre>

<p>
所以，不要为一个循环引用值组中的值设置终结器。
</p>

<p>
顺便说一下，我们<a href="unofficial-faq.html#finalizers">不应该把终结器用做析构函数</a>。
</p>
</div>

<h3>延迟调用函数导致的临时性内存泄露</h3>

<div>

<p>
请阅读<a href="defer-more.html#kind-of-resource-leaking">此文</a>以获得详情。
</p>

</div>


<!--
forgot closing streams

the capacity of the uderlying array of a map will never shrink.

defer in infinite/long-period loop
-->

